/*
 * JuigadorPoker.java
 *
 * Created on 17 de junio de 2007, 15:53
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package poker;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Vector;

/**
 *
 * @author jose
 */
public class JugadorPoker implements Comparator{
    
    public Carta carta1,carta2;
    Carta c1,c2,c3,c4,c5;
    public Valor valorJugador;
    private Entrada in;
    private Salida out;
    public int dinero;
    public int posicion;
    public int jugada = 0; // Indica la mejor jugada en la mano
    /** Creates a new instance of JugadorPoker */
    public JugadorPoker(int posicion) {
        this.posicion = posicion;
    }
    
    public void actualizarValorJugada(){
        valorJugador = this.obtenerValor();
        jugada = valorJugador.jugada;
                
    }
    public void asignarMano(Carta c1,Carta c2,Carta c3,Carta c4,Carta c5,Carta c6,Carta c7)
    {
        this.carta1 = c1;
        this.carta2 = c2;
        this.c1= c3;
        this.c2= c4;
        this.c3= c5;
        this.c4= c6;
        this.c5= c7;
        
    }
    public void asignarCartas(Carta c1,Carta c2)
    {
        carta1 = c1;
        carta2 = c2;
    }
    
    public void asignarFlop(Carta c1,Carta c2,Carta c3)
    {
        this.c1= c1;
        this.c2= c2;
        this.c3= c3;
        
    }
    public void asignarRiver(Carta c1)
    {
        this.c4= c1;
        
    }
    public void asignarTurn(Carta c1)
    {
        this.c5= c1;
        
    }
    
    // Comprueba si esta asignada la carta al jugador
    public boolean asinada(int n){
        if ((n==1) && (this.carta1.palo==0)) return false;
        if ((n==2) && (this.carta2.palo==0)) return false;
        if ((n==3) && (this.c1.palo==0)) return false;
        if ((n==4) && (this.c2.palo==0)) return false;
        if ((n==5) && (this.c3.palo==0)) return false;
        if ((n==6) && (this.c4.palo==0)) return false;
        if ((n==7) && (this.c5.palo==0)) return false;
        return true;
    }
    

    // 
    // CALCULO DE VALORES
    // ESCALERA DE COLOR = 16
    // POKER = 14
    // FULL = 12
    // COLOR = 10
    // ESCALERA = 8
    // TRIOS = 6
    // DOBLES PAREJAS = 4
    // PAREJAS = 2
    public Valor obtenerValor()
    {
        try 
        {
        Valor valor = new Valor();
        // Si hay escalera de color 
        if (this.escaleraDeColor())
        {
            // ESCALERA DE COLOR POR ABAJO
            int contadoresColor1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor3[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            if (carta1.getPalo()==1) contadoresColor1[carta1.valor]++;
            if (carta2.getPalo()==1) contadoresColor1[carta2.valor]++;
            if (c1.getPalo()==1) contadoresColor1[c1.valor]++;
            if (c2.getPalo()==1) contadoresColor1[c1.valor]++;
            if (c3.getPalo()==1) contadoresColor1[c1.valor]++;
            if (c4.getPalo()==1) contadoresColor1[c1.valor]++;
            if (c5.getPalo()==1) contadoresColor1[c1.valor]++;
            
            if (carta1.getPalo()==2) contadoresColor2[carta1.valor]++;
            if (carta2.getPalo()==2) contadoresColor2[carta2.valor]++;
            if (c1.getPalo()==2) contadoresColor2[c1.valor]++;
            if (c2.getPalo()==2) contadoresColor2[c2.valor]++;
            if (c3.getPalo()==2) contadoresColor2[c3.valor]++;
            if (c4.getPalo()==2) contadoresColor2[c4.valor]++;
            if (c5.getPalo()==2) contadoresColor2[c5.valor]++;
            
            if (carta1.getPalo()==3) contadoresColor3[carta1.valor]++;
            if (carta2.getPalo()==3) contadoresColor3[carta2.valor]++;
            if (c1.getPalo()==3) contadoresColor3[c1.valor]++;
            if (c2.getPalo()==3) contadoresColor3[c2.valor]++;
            if (c3.getPalo()==3) contadoresColor3[c3.valor]++;
            if (c4.getPalo()==3) contadoresColor3[c4.valor]++;
            if (c5.getPalo()==3) contadoresColor3[c5.valor]++;
            
            if (carta1.getPalo()==4) contadoresColor4[carta1.valor]++;
            if (carta2.getPalo()==4) contadoresColor4[carta2.valor]++;
            if (c1.getPalo()==4) contadoresColor4[c1.valor]++;
            if (c2.getPalo()==4) contadoresColor4[c2.valor]++;
            if (c3.getPalo()==4) contadoresColor4[c3.valor]++;
            if (c4.getPalo()==4) contadoresColor4[c4.valor]++;
            if (c5.getPalo()==4) contadoresColor4[c5.valor]++;

            if( ((contadoresColor1[2]>=1)&&(contadoresColor1[3]>=1)&&(contadoresColor1[4]>=1)&&(contadoresColor1[5]>=1)&&(contadoresColor1[14]>=1))
                || ((contadoresColor2[2]>=1)&&(contadoresColor2[3]>=1)&&(contadoresColor2[4]>=1)&&(contadoresColor2[5]>=1)&&(contadoresColor2[14]>=1))
                || ((contadoresColor3[2]>=1)&&(contadoresColor3[3]>=1)&&(contadoresColor3[4]>=1)&&(contadoresColor3[5]>=1)&&(contadoresColor3[14]>=1))
                || ((contadoresColor4[2]>=1)&&(contadoresColor4[3]>=1)&&(contadoresColor4[4]>=1)&&(contadoresColor4[5]>=1)&&(contadoresColor4[14]>=1)))
            {
                      
                valor.setValor(16,1,2,3,4,5); return valor;                
            }
            // FIN ESCALERA DE COLOR POR ABAJO
            Vector c = new Vector();
            Carta anterior = new Carta(99,99);
            Carta temp;
            int contador = 1;
            int contadorMax = 1;
            int cartaMasAlta = 0;
            c.add(carta1);
            c.add(carta2);
            c.add(c1);
            c.add(c2);
            c.add(c3);
            c.add(c4);
            c.add(c5);
            Collections.sort((List) c, new Carta(0,0));
            while (c.isEmpty() == false){

                 temp = (Carta) c.get(0);
                 if ((anterior.getValor()+1 == temp.getValor())&&(anterior.getPalo()== temp.getPalo()))
                    {                
                        contador++;
                        if (contador > contadorMax) contadorMax = contador;
                        if (temp.getValor() > cartaMasAlta) cartaMasAlta = temp.getValor(); 

                    }
                 else{
                    contador = 1;
                 }
                //System.out.println(c.get(0));

                anterior =(Carta) c.get(0);
                c.remove(0);
            }
            valor.setValor(16,cartaMasAlta,cartaMasAlta-1,cartaMasAlta-2,cartaMasAlta-3,cartaMasAlta-4);
           //if (contadorMax >= 5) return valor; 
           return valor;  
        }
        // FIN  Escalera de Color VALOR
        
        
        // Si hay POKER
        if (this.poker())
        {
                int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                int cartaPoker = 0;
                int cma = 0;
                contadores[carta1.valor]++;
                contadores[carta2.valor]++;
                contadores[c1.valor] =  contadores[c1.valor]+ 1;
                contadores[c2.valor] =  contadores[c2.valor]+ 1;
                contadores[c3.valor] =  contadores[c3.valor]+ 1;
                contadores[c4.valor] =  contadores[c4.valor]+ 1;
                contadores[c5.valor] =  contadores[c5.valor]+1;
                for (int i = 1;i<=14;i++)
                {
                    if ((contadores[i] >= 4) ) {
                        cartaPoker = i;
                    } else
                    {
                        if ((cma < i) && (contadores[i] != 0)) cma = i;
                    }
                }
                if (cartaPoker != 0)
                {
                    valor.setValor(14,cartaPoker,cartaPoker,cartaPoker,cartaPoker,cma);
                    return valor;
                }else return valor;
        }
        // FIN Poker VALOR
        
        // FULL
        if (this.full())
        {

                int max = 0;
                int imax = 0;
                int f1 = 0;
                int f2 = 0;
                int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                contadores[carta1.valor] =  contadores[carta1.valor]+ 1;
                contadores[carta2.valor] =  contadores[carta2.valor]+ 1;
                contadores[c1.valor] =  contadores[c1.valor]+ 1;
                contadores[c2.valor] =  contadores[c2.valor]+ 1;
                contadores[c3.valor] =  contadores[c3.valor]+ 1;
                contadores[c4.valor] =  contadores[c4.valor]+ 1;
                contadores[c5.valor] =  contadores[c5.valor]+1;
                for (int i = 1;i<=14;i++)
                {
                    if (contadores[i] >= 3) {
                        max++;
                        contadores[i] = 0;
                        if (f1 < i){
                            f2 = f1;
                            f1 = i;
                        }
                        
                        
                    }
                }
                for (int i = 1;i<=14;i++)
                {
                     if (contadores[i] >= 2) {
                        max++;
                        contadores[i] = 0;
                        if (f2 < i) f2 = i;
                    }
                }
                if (max >= 2)                
                {
                    valor.setValor(12,f1,f1,f1,f2,f2);
                    return valor;
                }else return valor;
        }
        // FIN FULL
        
        // COLOR
        if (this.color())
        {
                int contadores[] = {0,0,0,0,0};
                contadores[carta1.palo]++;
                contadores[carta2.palo]++;
                int maximo = 0;
                contadores[c1.palo] =  contadores[c1.palo]+ 1;
                contadores[c2.palo] =  contadores[c2.palo]+ 1;
                contadores[c3.palo] =  contadores[c3.palo]+ 1;
                contadores[c4.palo] =  contadores[c4.palo]+ 1;
                contadores[c5.palo] =  contadores[c5.palo]+1;
                
                for (int i = 1;i<=3;i++)
                {
                    if(contadores[i] >= 5)
                    {
                        if ((carta1.palo == i) && (carta1.valor >= maximo)) maximo = carta1.valor;
                        if ((carta2.palo == i) && (carta2.valor >= maximo)) maximo = carta2.valor;
                        if ((c1.palo == i) && (c1.valor >= maximo)) maximo = c1.valor;
                        if ((c2.palo == i) && (c2.valor >= maximo)) maximo = c2.valor;
                        if ((c3.palo == i) && (c3.valor >= maximo)) maximo = c3.valor;
                        if ((c4.palo == i) && (c4.valor >= maximo)) maximo = c4.valor;
                        if ((c5.palo == i) && (c5.valor >= maximo)) maximo = c5.valor;
                        
                        valor.setValor(10,maximo,maximo-1,maximo-2,maximo-3,maximo-4);
                        return valor;
                    }
                }
        }
       
       
        // Escalera
        if (this.escalera())
        {
            int maximo = 0;
            Vector c = new Vector();
            int anterior = 99;
            int contador = 1;
            int contadorMax = 1;
            c.add(carta1.valor);
            c.add(carta2.valor);
            c.add(c1.valor);
            c.add(c2.valor);
            c.add(c3.valor);
            c.add(c4.valor);
            c.add(c5.valor);
            Collections.sort((List) c);
            
            // ESCALERA POR ABAJO
            int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            contadores[carta1.valor]++;
            contadores[carta2.valor]++;
            contadores[c1.valor] =  contadores[c1.valor]+ 1;
            contadores[c2.valor] =  contadores[c2.valor]+ 1;
            contadores[c3.valor] =  contadores[c3.valor]+ 1;
            contadores[c4.valor] =  contadores[c4.valor]+ 1;
            contadores[c5.valor] =  contadores[c5.valor]+1;
            if ((contadores[2]>=1)&&(contadores[3]>=1)&&(contadores[4]>=1)&&(contadores[5]>=1)&&(contadores[14]>=1))
            {
                valor.setValor(8,5,4,3,2,1);  
                return valor;                 
            }
            // FIN ESCALERA POR ABAJO
            while (c.isEmpty() == false){
                if ((anterior + 1) == (Integer) c.get(0))
                {

                    if (maximo < (anterior + 1)) maximo = anterior + 1;
                    contador++;
                    if (contador > contadorMax) contadorMax = contador;

                }
                else if ((anterior) == (Integer) c.get(0));
                else
                    contador = 1;

                anterior =(Integer) c.get(0);
                //System.out.println(c.get(0));
                c.remove(0);
        }
        //System.out.println("Contador Maximo " + contadorMax);
        valor.setValor(8,maximo,maximo-1,maximo-2,maximo-3,maximo-4);                       
        if (contadorMax >= 5) return valor;
                
        }
        
        
        // Trio
        if (this.trio())
        {
            int maximo = 0;
            int m1 = 0;
            int m2 = 0;
            int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            contadores[carta1.valor]++;
            contadores[carta2.valor]++;
            contadores[c1.valor] =  contadores[c1.valor]+ 1;
            contadores[c2.valor] =  contadores[c2.valor]+ 1;
            contadores[c3.valor] =  contadores[c3.valor]+ 1;
            contadores[c4.valor] =  contadores[c4.valor]+ 1;
            contadores[c5.valor] =  contadores[c5.valor]+1;
            for (int i = 1;i<=14;i++)
            {
                if ((contadores[i] >= 3) ) {
                    if (maximo <= i) maximo = i;
                }
                else
                if ((i >= m1)&&(contadores[i]>=1))
                {
                    m2 = m1;
                    m1 = i;
                } else
                if ((i >= m2)&&(contadores[i]>=1))
                {
                    m2 = i;
                }
            }
            valor.setValor(6,maximo,maximo,maximo,m1,m2);
            return valor;
        }
        
        
        
        // Dobles Parejas
        if (this.doblesParejas())
        {
            int maximo = 0;
            int max = 0;
            int imax = 0;
            int v1 = 0;
            int v2 = 0;
            int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            contadores[carta1.valor]++;
            contadores[carta2.valor]++;
            contadores[c1.valor] =  contadores[c1.valor]+ 1;
            contadores[c2.valor] =  contadores[c2.valor]+ 1;
            contadores[c3.valor] =  contadores[c3.valor]+ 1;
            contadores[c4.valor] =  contadores[c4.valor]+ 1;
            contadores[c5.valor] =  contadores[c5.valor]+1;


            for (int i = 1;i<=14;i++)
            {
                if (contadores[i] >= 2) 
                {
                    max++;
                    if (i>v1) 
                    {
                        v2 = v1;
                        v1 = i;                        
                    } else
                    if (i>v2)
                    {
                        v2 = i;
                    } 
                } else if ((maximo < i) && (contadores[i] >= 1)) maximo = i; 
                    
             }
                valor.setValor(4,v1,v1,v2,v2,maximo);
                return valor;
            }
        
        
        // Pareja
        if (this.pareja())
        {
            int maximo = 0;
            int m1 = 0;
            int m2 = 0;
            int m3 = 0;
            int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            contadores[carta1.valor]++;
            contadores[carta2.valor]++;
            contadores[c1.valor] =  contadores[c1.valor]+ 1;
            contadores[c2.valor] =  contadores[c2.valor]+ 1;
            contadores[c3.valor] =  contadores[c3.valor]+ 1;
            contadores[c4.valor] =  contadores[c4.valor]+ 1;
            contadores[c5.valor] =  contadores[c5.valor]+1;
            for (int i = 1;i<=14;i++)
            {
                if ((contadores[i] >= 2) ) {
                    if (maximo < i) maximo = i;
                } else
                if ((i >= m1)&&(contadores[i]>=1))
                {
                    m3 = m2;
                    m2 = m1;                    
                    m1 = i;
                    
                } else
                if ((i >= m2)&&(contadores[i]>=1))
                {
                    m3 = m2;
                    m2 = i;
                    
                }
                else
                if ((i >= m3)&&(contadores[i]>=1))
                {
                    m3 = i;
                }  
            }
            valor.setValor(2,maximo,maximo,m1,m2,m3);
            return valor;
        }

        
       // A LA CARTA MAS ALTA
        Vector c = new Vector();
        c.add(carta1.valor);
        c.add(carta2.valor);
        c.add(c1.valor);
        c.add(c2.valor);
        c.add(c3.valor);
        c.add(c4.valor);
        c.add(c5.valor);
        Collections.sort((List) c);
        valor.setValor(0,(Integer)c.get(6),(Integer)c.get(5),(Integer)c.get(4),(Integer)c.get(3),(Integer)c.get(2));
        return valor;
            }
        catch (Exception ex){
            Valor valor = new Valor();
            valor.setValor(0,0,0,0,0,0);
            return valor;
        }
    }
    
    // JUGADAS
 
    public boolean escaleraDeColor()
    {   
        // REVISAR ESCALERA DE COLOR POR ABAJO
            // ESCALERA DE COLOR POR ABAJO

            int contadoresColor1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor2[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor3[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            int contadoresColor4[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            if (carta1.getPalo()==1) contadoresColor1[carta1.valor]++;
            if (carta2.getPalo()==1) contadoresColor1[carta2.valor]++;
            if (c1.getPalo()==1) contadoresColor1[c1.valor]++;
            if (c2.getPalo()==1) contadoresColor1[c2.valor]++;
            if (c3.getPalo()==1) contadoresColor1[c3.valor]++;
            if (c4.getPalo()==1) contadoresColor1[c4.valor]++;
            if (c5.getPalo()==1) contadoresColor1[c5.valor]++;
            
            if (carta1.getPalo()==2) contadoresColor2[carta1.valor]++;
            if (carta2.getPalo()==2) contadoresColor2[carta2.valor]++;
            if (c1.getPalo()==2) contadoresColor2[c1.valor]++;
            if (c2.getPalo()==2) contadoresColor2[c2.valor]++;
            if (c3.getPalo()==2) contadoresColor2[c3.valor]++;
            if (c4.getPalo()==2) contadoresColor2[c4.valor]++;
            if (c5.getPalo()==2) contadoresColor2[c5.valor]++;
            
            if (carta1.getPalo()==3) contadoresColor3[carta1.valor]++;
            if (carta2.getPalo()==3) contadoresColor3[carta2.valor]++;
            if (c1.getPalo()==3) contadoresColor3[c1.valor]++;
            if (c2.getPalo()==3) contadoresColor3[c2.valor]++;
            if (c3.getPalo()==3) contadoresColor3[c3.valor]++;
            if (c4.getPalo()==3) contadoresColor3[c4.valor]++;
            if (c5.getPalo()==3) contadoresColor3[c5.valor]++;
            
            if (carta1.getPalo()==4) contadoresColor4[carta1.valor]++;
            if (carta2.getPalo()==4) contadoresColor4[carta2.valor]++;
            if (c1.getPalo()==4) contadoresColor4[c1.valor]++;
            if (c2.getPalo()==4) contadoresColor4[c2.valor]++;
            if (c3.getPalo()==4) contadoresColor4[c3.valor]++;
            if (c4.getPalo()==4) contadoresColor4[c4.valor]++;
            if (c5.getPalo()==4) contadoresColor4[c5.valor]++;

            if( ((contadoresColor1[2]>=1)&&(contadoresColor1[3]>=1)&&(contadoresColor1[4]>=1)&&(contadoresColor1[5]>=1)&&(contadoresColor1[14]>=1))
                || ((contadoresColor2[2]>=1)&&(contadoresColor2[3]>=1)&&(contadoresColor2[4]>=1)&&(contadoresColor2[5]>=1)&&(contadoresColor2[14]>=1))
                || ((contadoresColor3[2]>=1)&&(contadoresColor3[3]>=1)&&(contadoresColor3[4]>=1)&&(contadoresColor3[5]>=1)&&(contadoresColor3[14]>=1))
                || ((contadoresColor4[2]>=1)&&(contadoresColor4[3]>=1)&&(contadoresColor4[4]>=1)&&(contadoresColor4[5]>=1)&&(contadoresColor4[14]>=1)))
            {
                      
                return true;                 
            }
            // FIN ESCALERA POR ABAJO
        
        //
        Vector c = new Vector();
        Carta anterior = new Carta(99,99);
        Carta temp;
        int contador = 1;
        int contadorMax = 1;
        c.add(carta1);
        c.add(carta2);
        c.add(c1);
        c.add(c2);
        c.add(c3);
        c.add(c4);
        c.add(c5);
        Collections.sort((List) c, new Carta(0,0));
        while (c.isEmpty() == false){
 
             temp = (Carta) c.get(0);
             if ((anterior.getValor()+1 == temp.getValor())&&(anterior.getPalo()== temp.getPalo()))
                {                
                    contador++;
                    if (contador > contadorMax) contadorMax = contador;

                }
             else{
                contador = 1;
             }
            //System.out.println(c.get(0));

            anterior =(Carta) c.get(0);
            c.remove(0);
             
        }
       // System.out.println("Contador Maximo " + contadorMax);
        if (contadorMax >= 5) return true;
        else return false;
    }  

    public boolean poker()
    {
        //if (this.escaleraDeColor()) return false;
        int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        contadores[carta1.valor]=  contadores[carta1.valor]+ 1;
        contadores[carta2.valor]=  contadores[carta2.valor]+ 1;
        contadores[c1.valor] =  contadores[c1.valor]+ 1;
        contadores[c2.valor] =  contadores[c2.valor]+ 1;
        contadores[c3.valor] =  contadores[c3.valor]+ 1;
        contadores[c4.valor] =  contadores[c4.valor]+ 1;
        contadores[c5.valor] =  contadores[c5.valor]+1;
        for (int i = 1;i<=14;i++)
        {
            if ((contadores[i] >= 4) ) {
                return true;
            }
        }


        return false;
        
    }
    
    public boolean color()
    {   
        //if (this.full()) return false;        
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        Vector c = new Vector();
        int anterior = 99;
        int contador = 1;
        int contadorMax = 1;
        c.add(carta1.palo);
        c.add(carta2.palo);
        c.add(c1.palo);
        c.add(c2.palo);
        c.add(c3.palo);
        c.add(c4.palo);
        c.add(c5.palo);
        while (c.isEmpty() == false){
            Collections.sort((List) c);
             if ((anterior) == (Integer) c.get(0))
                {                
                    contador++;
                    if (contador > contadorMax) contadorMax = contador;

                }
             else{
                contador = 1;
             }
            //System.out.println(c.get(0));

        anterior =(Integer) c.get(0);
             c.remove(0);
             
        }
        //System.out.println("Contador Maximo " + contadorMax);
        if (contadorMax >= 5) return true;
        else return false;
    }     

    public boolean full()
    {
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        
        int max = 0;
        int imax = 0;
        int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        contadores[carta1.valor] =  contadores[carta1.valor]+ 1;
        contadores[carta2.valor] =  contadores[carta2.valor]+ 1;
        contadores[c1.valor] =  contadores[c1.valor]+ 1;
        contadores[c2.valor] =  contadores[c2.valor]+ 1;
        contadores[c3.valor] =  contadores[c3.valor]+ 1;
        contadores[c4.valor] =  contadores[c4.valor]+ 1;
        contadores[c5.valor] =  contadores[c5.valor]+1;
        for (int i = 1;i<=14;i++)
        {
            if (contadores[i] >= 3) {
                max = 1;
                contadores[i] = 0;
                break;
            }
        }
        for (int i = 1;i<=14;i++)
        {
            if (contadores[i] >= 2) {
                max++;
                contadores[i] = 0;
                break;
            }
        }
         if (max >= 2) return true; else return false;
     }
    
    public boolean escalera()
    {
        //if (this.color()) return false;
        //if (this.full()) return false;        
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        
        
            // ESCALERA POR ABAJO
            int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
            contadores[carta1.valor]++;
            contadores[carta2.valor]++;
            contadores[c1.valor] =  contadores[c1.valor]+ 1;
            contadores[c2.valor] =  contadores[c2.valor]+ 1;
            contadores[c3.valor] =  contadores[c3.valor]+ 1;
            contadores[c4.valor] =  contadores[c4.valor]+ 1;
            contadores[c5.valor] =  contadores[c5.valor]+1;
            if ((contadores[2]>=1)&&(contadores[3]>=1)&&(contadores[4]>=1)&&(contadores[5]>=1)&&(contadores[14]>=1))
            {
                return true;                 
            }
            // FIN ESCALERA POR ABAJO
        
        Vector c = new Vector();
        int anterior = 99;
        int contador = 1;
        int contadorMax = 1;
        c.add(carta1.valor);
        c.add(carta2.valor);
        c.add(c1.valor);
        c.add(c2.valor);
        c.add(c3.valor);
        c.add(c4.valor);
        c.add(c5.valor);
        Collections.sort((List) c);
        while (c.isEmpty() == false){
            if ((anterior + 1) == (Integer) c.get(0))
            {
                
                contador++;
                if (contador > contadorMax) contadorMax = contador;
                
            }
            else if ((anterior) == (Integer) c.get(0));
            else
                contador = 1;
            
            anterior =(Integer) c.get(0);
            //System.out.println(c.get(0));
            c.remove(0);
        }
        //System.out.println("Contador Maximo " + contadorMax);
        if (contadorMax >= 5) return true;
        else return false;
    }
    
    public boolean trio()
    {
        //if (this.escalera()) return false;
        //if (this.color()) return false;
        //if (this.full()) return false;        
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        contadores[carta1.valor]++;
        contadores[carta2.valor]++;
        contadores[c1.valor] =  contadores[c1.valor]+ 1;
        contadores[c2.valor] =  contadores[c2.valor]+ 1;
        contadores[c3.valor] =  contadores[c3.valor]+ 1;
        contadores[c4.valor] =  contadores[c4.valor]+ 1;
        contadores[c5.valor] =  contadores[c5.valor]+1;
        for (int i = 1;i<=14;i++)
        {
            if ((contadores[i] >= 3) ) {
                return true;
            }
        }

        
        return false;
        
    }
    
    public boolean doblesParejas()
    {
        //if (this.trio()) return false;
        //if (this.escalera()) return false;
        //if (this.color()) return false;
        //if (this.full()) return false;        
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        int max = 0;
        int imax = 0;
        int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        contadores[carta1.valor]++;
        contadores[carta2.valor]++;
        contadores[c1.valor] =  contadores[c1.valor]+ 1;
        contadores[c2.valor] =  contadores[c2.valor]+ 1;
        contadores[c3.valor] =  contadores[c3.valor]+ 1;
        contadores[c4.valor] =  contadores[c4.valor]+ 1;
        contadores[c5.valor] =  contadores[c5.valor]+1;
        
        if (this.trio()) return false;
        
        for (int i = 1;i<=14;i++)
        {
            if ((contadores[i] >= 2) && (max != 1)) {
                max = 1;
                contadores[i] = 0;
            }
        }
        for (int i = 1;i<=14;i++)
        {
            if (contadores[i] >= 2) {
                max++;
                contadores[i] = 0;
                //SalidaEstandar s = new SalidaEstandar();
                //this.imprimirMano(s);
                return true;
            }
        }
        
        return false;
        
    }
    
    public boolean pareja()
    {
        //if (this.doblesParejas()) return false;
        //if (this.trio()) return false;
        //if (this.escalera()) return false;
        //if (this.color()) return false;
        //if (this.full()) return false;        
        //if (this.poker()) return false;
        //if (this.escaleraDeColor()) return false;
        
        int contadores[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        contadores[carta1.valor]++;
        contadores[carta2.valor]++;
        contadores[c1.valor] =  contadores[c1.valor]+ 1;
        contadores[c2.valor] =  contadores[c2.valor]+ 1;
        contadores[c3.valor] =  contadores[c3.valor]+ 1;
        contadores[c4.valor] =  contadores[c4.valor]+ 1;
        contadores[c5.valor] =  contadores[c5.valor]+1;
        for (int i = 1;i<=14;i++)
        {
            if ((contadores[i] >= 2) ) {
                return true;
            }
        }

        
        return false;
        
    }
     

     
     // Interfaz E/S
     public void imprimirMano(Salida s){
         String salida = "";
         salida = this.carta1.getPalo() + " " + this.carta1.getValor() + "\n";
         salida = this.carta2.getPalo() + " " + this.carta2.getValor() + "\n" + salida;
         salida = this.c1.getPalo() + " " + this.c1.getValor() + "\n" + salida;
         salida = this.c2.getPalo() + " " + this.c2.getValor() + "\n" + salida;
         salida = this.c3.getPalo() + " " + this.c3.getValor() + "\n" + salida;
         salida = this.c4.getPalo() + " " + this.c4.getValor() + "\n" + salida;
         salida = this.c5.getPalo() + " " + this.c5.getValor() + "\n" + salida;
         s.imprimir(salida);
     }
     public String imprimirMano(){
         String salida = "";
         salida = this.carta1.getPalo() + " " + this.carta1.getValor() + "\n";
         salida = this.carta2.getPalo() + " " + this.carta2.getValor() + "\n" + salida;
         salida = this.c1.getPalo() + " " + this.c1.getValor() + "\n" + salida;
         salida = this.c2.getPalo() + " " + this.c2.getValor() + "\n" + salida;
         salida = this.c3.getPalo() + " " + this.c3.getValor() + "\n" + salida;
         salida = this.c4.getPalo() + " " + this.c4.getValor() + "\n" + salida;
         salida = this.c5.getPalo() + " " + this.c5.getValor() + "\n" + salida;
         return salida;
     }
     // Pregunta si quieren ver o apostar
     public int preguntar(int bote){
         return 0;
     }
     
     
    // Implements compare
    /*
     public int compare(Object a, Object b) {
        int a1,a2;
        JugadorPoker j1 = (JugadorPoker) a ;
        if (j1.jugada == 0)
        {
            a1=0;
            a1 = j1.obtenerValor().c5;
            a1 = a1 + j1.obtenerValor().c4 * 16;
            a1 = a1 + j1.obtenerValor().c3 * 16 * 16;
            a1 = a1 + j1.obtenerValor().c2 * 16 * 16 * 16;
            a1 = a1 + j1.obtenerValor().c1 * 16 * 16 * 16 * 16;
            a1 = a1 + j1.obtenerValor().jugada * 18 * 16 * 16 * 16 * 16;
        }
        else
        {
            a1 = j1.jugada;
        }
        
        JugadorPoker j2 = (JugadorPoker) b;
        if (j1.jugada == 0)
        {
            a2=0;
            a2 = j2.obtenerValor().c5;
            a2 = a2 + j2.obtenerValor().c4 * 16;
            a2 = a2 + j2.obtenerValor().c3 * 16 * 16;
            a2 = a2 + j2.obtenerValor().c2 * 16 * 16 * 16;
            a2 = a2 + j2.obtenerValor().c1 * 16 * 16 * 16 * 16;
            a2 = a2 + j2.obtenerValor().jugada * 18 * 16 * 16 * 16 * 16;
        }
        else
        {
            a2 = j2.jugada;
        }
      
     return a2-a1;
    }
    */
    public void apostar(int dinero,Bote bote){
        
    }

   public int compare(Object a, Object b) {
        int a1,a2;
        JugadorPoker j1 = (JugadorPoker) a ;
        if (j1.jugada == 0)
        {
            a1=0;
            a1 = j1.obtenerValor().c5;
            a1 = a1 + j1.obtenerValor().c4 * 16;
            a1 = a1 + j1.obtenerValor().c3 * 16 * 16;
            a1 = a1 + j1.obtenerValor().c2 * 16 * 16 * 16;
            a1 = a1 + j1.obtenerValor().c1 * 16 * 16 * 16 * 16;
            a1 = a1 + j1.obtenerValor().jugada * 18 * 16 * 16 * 16 * 16;
        }
        else
        {
            a1 = j1.jugada;
        }
        
        JugadorPoker j2 = (JugadorPoker) b;
        if (j1.jugada == 0)
        {
            a2=0;
            a2 = j2.obtenerValor().c5;
            a2 = a2 + j2.obtenerValor().c4 * 16;
            a2 = a2 + j2.obtenerValor().c3 * 16 * 16;
            a2 = a2 + j2.obtenerValor().c2 * 16 * 16 * 16;
            a2 = a2 + j2.obtenerValor().c1 * 16 * 16 * 16 * 16;
            a2 = a2 + j2.obtenerValor().jugada * 18 * 16 * 16 * 16 * 16;
        }
        else
        {
            a2 = j2.jugada;
        }
      
     return a2-a1;
    }


 
}
